home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / The World of Computer Software.iso / xautolk.zip / XAUTOLK < prev   
Text File  |  1993-01-28  |  55KB  |  1,925 lines
  1.  
  2. Hello,
  3.  
  4.  
  5. This is patchlevel 8 of xautolock, the program which monitors console
  6. activity, and starts up a program of  your choice if nothing  happens
  7. during a certain time interval.  
  8.  
  9.  
  10. What's new?
  11. -----------
  12.  
  13.  - It supports multiheaded displays.
  14.  - It now uses the X resource database.
  15.  - The copyright notice has been changed considerably.
  16.  - The notification margin and bell percentage can be specified by
  17.    the user.
  18.  - It no longer steals events from windowmanagers that use a pseudo
  19.    root window.
  20.  - It no longer needs to get pointer events, so the chances of it
  21.    messing up event propagation have become even smaller.
  22.  - It can be disabled or activated by moving the pointer into one
  23.    of the corners of the display. This is highly customizable.
  24.  - It can be disabled (and re-enabled) by sending it a SIGHUP.
  25.  - By default, it now closes stdout and stderr, so you no longer
  26.    get zillions of error messages if you manually lock your display.
  27.  - The code is has become more foolproof (patchlevel 7 users
  28.    will have a hard time recognizing it :-).
  29.  
  30.  
  31. What hasn't been done yet?
  32. --------------------------
  33.  
  34.  - It still is contained in a single source file.
  35.  
  36.  
  37. Important
  38. ---------
  39.  
  40. Users of swm and tvtwm, (especially on Sparcs) are adviced to read
  41. the WARNING section in the README file.
  42.  
  43.  
  44.                           SDT & MCE
  45.  
  46. 8<- CUT HERE ---------------------------------------------------------
  47. #! /bin/sh
  48. # This is a shell archive, meaning:
  49. # 1. Remove everything above the #! /bin/sh line.
  50. # 2. Save the resulting text in a file.
  51. # 3. Execute the file with /bin/sh (not csh) to create the files:
  52. #    xautolock
  53. # This archive created: Fri Jun 19 22:28:31 1992
  54. export PATH; PATH=/bin:$PATH
  55. if test ! -d 'xautolock'
  56. then
  57.     echo shar: creating directory "'xautolock'"
  58.     mkdir 'xautolock'
  59. fi
  60. echo shar: entering directory "'xautolock'"
  61. cd 'xautolock'
  62. echo shar: extracting "'xautolock.man'" '(5719 characters)'
  63. if test -f 'xautolock.man'
  64. then
  65.     echo shar: will not over-write existing file "'xautolock.man'"
  66. else
  67. sed 's/^X//' << \SHAR_EOF > 'xautolock.man'
  68. X.TH xautolock l
  69. X
  70. X
  71. X.SH NAME
  72. X
  73. Xxautolock \- locks X display after a period of inactivity
  74. X
  75. X
  76. X.SH SYNOPSIS 
  77. X
  78. X\fBxautolock\fR [\fB\-help\fR] [\fB\-version\fR] 
  79. X[\fB\-time\fR \fIminutes\fR] [\fB\-locker\fR \fIlocker\fR]
  80. X          [\fB\-notify \fImargin\fR] [\fB\-bell \fIpercent\fR]
  81. X[\fB\-corners\fR \fIxxxx\fR]
  82. X          [\fB\-cornerdelay\fR \fIsecs\fR]
  83. X[\fB\-cornersize\fR \fIpixels\fR] [\fB\-noclose\fR]
  84. X.br 
  85. X
  86. X
  87. X.SH DESCRIPTION 
  88. X
  89. XWhen xautolock is started, it monitors the user activity on the
  90. Xworkstation. When no activity is detected within \fIminutes\fR
  91. Xminutes, the screen is automatically locked, using the screen
  92. Xlocker specified with the \fI\-locker\fR option. xautolock is
  93. Xcapable of managing multiheaded displays.
  94. X
  95. XIn the presence of the \fI\-notify\fR option, a warning signal will
  96. Xbe issued \fImargin\fR seconds before starting the locker. The
  97. X\fI\-bell\fR option specifies the loudness of the signal in
  98. X\fIpercent\fR.
  99. X
  100. XYou can tell xautolock to take special actions when you move
  101. Xthe mouse into one of the corners of the display and leave it
  102. Xthere, by using the \fI\-corners\fR,
  103. X\fI\-cornerdelay\fR and \fI\-cornersize\fR
  104. Xoptions. This works as follows :
  105. X
  106. XThe \fIxxxx\fR argument to the \fI\-corners\fR option must consist
  107. Xof exactly 4 characters from the following set : '0', '+', '-'.
  108. XEach one of these specifies what xautolock should do when the mouse
  109. Xenters a small square area located in each of the corners of the
  110. Xscreen. The corners are considered in the
  111. Xfollowing order : top left, top right, bottom left, bottom right.
  112. XA '0' indicates that xautolock should ignore the corner.
  113. XA '+' indicates that xautolock should start the \fIlocker\fR 
  114. Xafter \fIsecs\fR seconds, unless the mouse is moved, or keyboard
  115. Xinput is received. A '-' indicates that xautolock not start the
  116. X\fIlocker\fR at all. The \fIpixels\fR argument specifies the
  117. Xsize in pixels of the corner areas.
  118. X
  119. XBy default xautolock closes stdout and stderr. This prevents the
  120. Xscreenlocker from writing error messages to these files in case
  121. Xyou manually lock your display. The \fI\-noclose\fR option causes
  122. Xxautolock not to close stdout and stderr. This can be used for
  123. Xdebugging.
  124. X
  125. XYou can also disable xautolock by sending it a SIGHUP
  126. Xsignal. When disabled, it will not attempt to start the
  127. Xscreenlocker. To re-enable it, send it another SIGHUP. This 
  128. Xmethod is preferable to using SIGSTOP and SIGCONT, because
  129. Xwhile SIGHUPped, xautolock will still be emptying its 
  130. Xevent queue.
  131. X
  132. X
  133. X.SH OPTIONS
  134. X
  135. X.TP 14
  136. X\fB\-help\fR
  137. XPrint a help message and exit.
  138. X.TP 
  139. X\fB\-version\fR
  140. XPrint the version number and exit.
  141. X.TP 
  142. X\fB\-time\fR
  143. XSpecifies the time-out interval. The default is 10 minutes,
  144. Xthe minimum is 1 minute and the maximum is 1 hour.
  145. X.TP 
  146. X\fB\-locker\fR
  147. XSpecifies the screen locker to be used. The default is
  148. X"xlock 2>&- 1>&-". Your PATH is used to locate the program.
  149. XNotice that if \fIlocker\fR contains several words, it must
  150. Xbe specified between quotes.
  151. X.TP 
  152. X\fB\-notify\fR
  153. XWarn the user \fImargin\fR seconds before locking. The
  154. Xdefault is not to warn the user.
  155. X.TP
  156. X\fB\-bell\fR
  157. XSpecifies the loudness of the notification signal. The default
  158. Xis 40 percent. This option is only usefull in conjunction with
  159. X\fI\-notify\fR.
  160. X.TP 
  161. X\fB\-corners\fR
  162. XDefine special actions to be taken when the mouse
  163. Xenters one of the corners of the display. The default is 0000,
  164. Xwhich means that no special actions are taken.
  165. X.TP 
  166. X\fB\-cornerdelay\fR
  167. XSpecifies the number of seconds to wait
  168. Xbefore reacting to a '+' corner. The default is 5 seconds.
  169. X.TP 
  170. X\fB\-cornersize\fR
  171. XSpecifies the size in pixels of the corner areas. The default is
  172. X10 pixels.
  173. X.TP 
  174. X\fB\-noclose\fR
  175. XDon't close stdout and stderr.
  176. X
  177. X
  178. X.SH RESOURCES
  179. X
  180. X.TP 14
  181. X.B time 
  182. XSpecifies the time out period.
  183. X.TP 14
  184. X.B locker 
  185. XSpecifies the screen locker. No quotes are needed, even if
  186. Xyour screen locker command contains several words.
  187. X.TP 14
  188. X.B notify 
  189. XSpecifies the notification margin.
  190. X.TP 14
  191. X.B bell 
  192. XSpecifies the notification loudness.
  193. X.TP 14
  194. X.B corners 
  195. XSpecifies the corner behaviour.
  196. X.TP 14
  197. X.B cornersize 
  198. XSpecifies the size of the corner areas.
  199. X.TP 14
  200. X.B cornerdelay 
  201. XSpecifies the delay of a '+' corner.
  202. X.TP 14
  203. X.B noclose 
  204. XDon't close stdout and stderr.
  205. X
  206. X.TP 0
  207. XResources can be specified in your \fI~/.Xdefaults\fR file either
  208. Xfor class \fIXautolock\fR, or for whatever name you renamed
  209. Xxautolock to. For example : if you have two copies of xautolock,
  210. Xone called "xfreeze", and one called "xmonitor", then both will
  211. Xunderstand the following :
  212. X
  213. X  Xautolock.corners: ++++
  214. X
  215. XIn addition, "xfreeze" will understand :
  216. X
  217. X  xfreeze.cornersize: 10
  218. X
  219. Xwhile "xmonitor" will understand :
  220. X
  221. X  xmonitor.cornersize: 5
  222. X
  223. X
  224. X.SH KNOWN\ BUGS 
  225. X
  226. Xxautolock does not check whether \fIlocker\fR is available.
  227. X
  228. XThe xautolock resources have no resource class. 
  229. X
  230. X
  231. X.SH COPYRIGHT
  232. X
  233. XCopyright 1990, 1992 by S. De Troch and MCE.
  234. X
  235. XPermission to use, copy, modify and distribute this software and the
  236. Xsupporting documentation without fee is hereby granted, provided that :
  237. X
  238. X 1 : Both the above copyright notice and this permission notice
  239. X     appear in all copies of both the software and the supporting
  240. X     documentation.
  241. X 2 : You don't make a profit out of it.
  242. X
  243. XTHE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  244. XINCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
  245. XEVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  246. XDAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
  247. XOR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  248. XTORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  249. XPERFORMANCE OF THIS SOFTWARE.
  250. X
  251. X
  252. X.SH AUTHORS   
  253. X
  254. XStefan De Troch (detroch@imec.be),
  255. XMichel Eyckmans (eyckmans@imec.be).
  256. X
  257. X
  258. X.SH SPECIAL\ THANKS\ TO
  259. X
  260. XKris Croes (croes@imec.be).
  261. SHAR_EOF
  262. if test 5719 -ne "`wc -c < 'xautolock.man'`"
  263. then
  264.     echo shar: error transmitting "'xautolock.man'" '(should have been 5719 characters)'
  265. fi
  266. fi # end of overwriting check
  267. echo shar: extracting "'Imakefile'" '(498 characters)'
  268. if test -f 'Imakefile'
  269. then
  270.     echo shar: will not over-write existing file "'Imakefile'"
  271. else
  272. sed 's/^X//' << \SHAR_EOF > 'Imakefile'
  273. X#
  274. X#  Uncomment this if your compiler supports prototypes.
  275. X#
  276. X#  PROTOTYPES = -DHasPrototypes
  277. X
  278. X#ifdef HasVoidSignalReturn
  279. X   VOIDSIGNAL = -DHasVoidSignalReturn
  280. X#endif /* HasVoidSignalReturn */
  281. X
  282. X#if SunOSPlatform == YES
  283. X#
  284. X#  Circumvent a bug in the sun4 optimizer
  285. X#
  286. X  CDEBUGFLAGS = -g
  287. X#endif /* SunOSPlatform */
  288. X
  289. X      DEFINES = $(PROTOTYPES) $(VOIDSIGNAL) 
  290. XSYS_LIBRARIES = -lX11 
  291. X         HDRS = patchlevel.h 
  292. X         SRCS = xautolock.c 
  293. X         OBJS = xautolock.o 
  294. X
  295. XSimpleProgramTarget(xautolock)
  296. SHAR_EOF
  297. if test 498 -ne "`wc -c < 'Imakefile'`"
  298. then
  299.     echo shar: error transmitting "'Imakefile'" '(should have been 498 characters)'
  300. fi
  301. fi # end of overwriting check
  302. echo shar: extracting "'README'" '(4557 characters)'
  303. if test -f 'README'
  304. then
  305.     echo shar: will not over-write existing file "'README'"
  306. else
  307. sed 's/^X//' << \SHAR_EOF > 'README'
  308. X 
  309. XPURPOSE
  310. X=======
  311. X
  312. XXautolock is a program which monitors console activity, and starts up
  313. Xa program of  your choice if  nothing  happens  during a certain time
  314. Xinterval.  You can use this to automatically start up a screen locker
  315. Xin case you tend  to forget to do so  manually before having a coffee
  316. Xbreak.
  317. X
  318. X 
  319. XHARDWARE PLATFORMS
  320. X==================
  321. X
  322. XWe have used  xautolock  on the following hardware without problems :
  323. X
  324. XDECstation 3100 to 5500
  325. XHP Apollo 9000/4xx (Sr10)
  326. XSony News 1800
  327. XSparc II
  328. XVAXen (Ultrix)
  329. X
  330. XOther people have reported that it should also work on :
  331. X
  332. XSun386
  333. XIBM RS/6000
  334. XVAXstation 3100 
  335. X
  336. XAn  earlier  version also ran on  the following machinery,  but we no
  337. Xlonger have those, so testing it was a bit difficult :-). 
  338. X
  339. XSun 3/60
  340. XApollo 3000 to 4500
  341. X
  342. X 
  343. XHOW TO USE IT
  344. X=============
  345. X 
  346. XJust read the man page, it's really simple.
  347. X
  348. X
  349. XHOW IT WORKS
  350. X============
  351. X
  352. XWhen  xautolock  starts  executing,  it  traverses  the  window tree, 
  353. Xselects  SubstructureNotify  on all windows and adds each window to a
  354. Xtemporary list.  About +- 30 seconds later,  it scans this list,  and
  355. Xnow  asks for KeyPress events.  However,  it takes care to  interfere 
  356. Xas litle as possible  with  the event propagation mechanism.  This is
  357. Xthe reason for the delay between the moment  xautolock learns about a
  358. Xnew window (and consequently asks for  SubstructureNotify events) and
  359. Xthe moment it asks for KeyPress.  Whenever a new window is created, a
  360. Xsimilar process takes place.
  361. X
  362. XIn addition, xautolock issues a  QueryPointer  request once a second,
  363. Xin order to find out wether the pointer has moved.
  364. X
  365. XIf nothing happens within a user-specified period of time,  xautolock
  366. Xwill fire up a program  which is supposed  to lock the screen.  While
  367. Xthis program is running, xautolock itself remains on the look-out for
  368. Xuser interaction.
  369. X
  370. XIn contradiction  to what many people  believe,  this scheme does not
  371. Xcause a noticeable overhead. 
  372. X
  373. X
  374. XCOMPILING XAUTOLOCK
  375. X===================
  376. X
  377. XXautolock  should  compile  straight  out of  the box.  Just  do  the
  378. Xfollowing :
  379. X
  380. X 1 : Type 
  381. X
  382. X      xmkmf 
  383. X      make
  384. X      make install
  385. X      make clean 
  386. X
  387. X 2 : Have fun.
  388. X
  389. X 
  390. XKNOWN BUGS
  391. X==========
  392. X
  393. XIf,  when creating  a window,  an application  waits for more than 30
  394. Xseconds before calling XSelectInput (),  xautolock may interfere with
  395. Xthe  event propagation  mechanism.  In order to minimize  the risk of
  396. Xthis happening,  an extra delay of 20 seconds  has been inserted into
  397. Xthe   xautolock  initialization  sequence.   This  was  done  because
  398. Xxautolock is most likely to be started automatically when a user logs
  399. Xin, and that process can be rather time-consuming.
  400. X
  401. XXautolock  does not check whether the screenlocker specified actually
  402. Xis available.
  403. X
  404. XThe xautolock resources have no resource class.
  405. X
  406. XIf you can find others, please send e-mail to one of the authors.
  407. X
  408. X
  409. XWARNING
  410. X=======
  411. X
  412. XThere  is  a  bug  in  the  event management code  of some  X servers
  413. X(amongst  which  both  X11R4  and X11R5  on Sparc).  If you are using 
  414. Xpatchlevel  7  of  xautolock,  it is best to reset  the server before
  415. Xswitching to patchlevel 8.  If you fail to do so, an old patchlevel 7
  416. Xbug may still show up.  (Some keybaord events were being  hijacked by
  417. Xpatchlevel 7 of xautolock, particularly when using tvtwm). 
  418. X
  419. X
  420. XCOPYRIGHT
  421. X=========
  422. X 
  423. XCopyright 1990, 1992 by S. De Troch and MCE.
  424. X
  425. XPermission to use, copy, modify and distribute this software and the
  426. Xsupporting documentation without fee is hereby granted, provided that :
  427. X
  428. X 1 : Both the above copyright notice and this permission notice
  429. X     appear in all copies of both the software and the supporting
  430. X     documentation.
  431. X 2 : You don't make a profit out of it.
  432. X
  433. X 
  434. XDISCLAIMER
  435. X==========
  436. X
  437. XTHE AUTHORS  DISCLAIM  ALL WARRANTIES  WITH  REGARD TO THIS SOFTWARE,
  438. XINCLUDING  ALL IMPLIED WARRANTIES OF MERCHANTABILITY  AND FITNESS, IN
  439. XNO  EVENT  SHALL THEY   BE  LIABLE  FOR   ANY  SPECIAL,  INDIRECT  OR
  440. XCONSEQUENTIAL DAMAGES  OR ANY DAMAGES WHATSOEVER  RESULTING FROM LOSS
  441. XOF  USE,  DATA  OR  PROFITS,   WHETHER  IN  AN  ACTION  OF  CONTRACT,
  442. XNEGLIGENCE  OR   OTHER   TORTIOUS  ACTION,   ARISING  OUT  OF  OR  IN
  443. XCONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  444. X
  445. X 
  446. XAUTHORS
  447. X=======
  448. X
  449. XXautolock was conceived, written and performed by :
  450. X
  451. X Stefan De Troch             detroch@imec.be
  452. X Michel Eyckmans (MCE)       eyckmans@imec.be
  453. X
  454. X
  455. XACKNOWLEDGEMENTS
  456. X================
  457. X
  458. XSpecial thanks to :
  459. X
  460. X Kris Croes                  croes@imec.be
  461. X
  462. XAnd the patchlevel 8 beta testers :
  463. X
  464. X Paul D. Smith               paul_smith@dg.com
  465. X Brian                       brian@natinst.com
  466. SHAR_EOF
  467. if test 4557 -ne "`wc -c < 'README'`"
  468. then
  469.     echo shar: error transmitting "'README'" '(should have been 4557 characters)'
  470. fi
  471. fi # end of overwriting check
  472. echo shar: extracting "'patchlevel.h'" '(22 characters)'
  473. if test -f 'patchlevel.h'
  474. then
  475.     echo shar: will not over-write existing file "'patchlevel.h'"
  476. else
  477. sed 's/^X//' << \SHAR_EOF > 'patchlevel.h'
  478. X#define PATCHLEVEL  8
  479. SHAR_EOF
  480. if test 22 -ne "`wc -c < 'patchlevel.h'`"
  481. then
  482.     echo shar: error transmitting "'patchlevel.h'" '(should have been 22 characters)'
  483. fi
  484. fi # end of overwriting check
  485. echo shar: extracting "'xautolock.c'" '(37774 characters)'
  486. if test -f 'xautolock.c'
  487. then
  488.     echo shar: will not over-write existing file "'xautolock.c'"
  489. else
  490. sed 's/^X//' << \SHAR_EOF > 'xautolock.c'
  491. X/***************************************************************************
  492. X *
  493. X * xautolock
  494. X * =========
  495. X *
  496. X * Authors   :  S. De Troch (SDT)
  497. X *              M. Eyckmans (MCE)
  498. X *
  499. X * Date      :  22/07/90
  500. X *
  501. X * Comments  :
  502. X *
  503. X * Review    :  - 12/02/92 (MCE) :
  504. X *                . Hacked around a dxcalendar problem.
  505. X *              - 21/02/92 (MCE) :
  506. X *                . Major rewrite.
  507. X *              - 24/02/92 (MCE) :
  508. X *                . Removed an initialization bug.
  509. X *              - 25/02/92 (MCE) :
  510. X *                . Added code to detect multiple invocations.
  511. X *              - 06/03/92 (MCE) :
  512. X *                . Re-arranged the event loop in order to detect defunct
  513. X *                  children as soon as possible.
  514. X *              - 10/03/92 (SDT & MCE) :
  515. X *                . Added code to detect broken server connections.
  516. X *              - 24/03/92 (MCE) :
  517. X *                . Don't reset the time-out counter after receiving a
  518. X *                  synthetic or otherwise unexpected event.
  519. X *              - 15/04/92 (MCE) :
  520. X *                . Changed the default locker to "xlock 2>&- 1>&-".
  521. X *                . Fixed a couple of event mask bugs. (Thanks to
  522. X *                  jwz@lucid.com for running into these.)
  523. X *                . Corrected a property type bug in CheckConnection ().
  524. X *              - 20/04/92 (MCE) :
  525. X *                . Cut Main () into more managable pieces.
  526. X *                . Periodically call XQueryPointer ().
  527. X *              - 25/04/92 (MCE) :
  528. X *                . Added the `corners' feature. (Suggested by
  529. X *                  weisen@alw.nih.gov.)
  530. X *                . Fixed a problem with pseudo-root windows. (Thanks to
  531. X *                  sherman@unx.sas.com, nedwards@titan.trl.OZ.AU,
  532. X *                  dave@elxr.jpl.Nasa.Gov and tmcconne@sedona.intel.com
  533. X *                  for pointing out the problem and testing the patch.)
  534. X *                . Added `disable/enable on SIGHUP'. (Suggested by
  535. X *                  paul_smith@dg.com.)
  536. X *                . Added support for multiheaded displays. 
  537. X *              - 28/04/92 (MCE) :
  538. X *                . Use the X resource manager.
  539. X *              - 06/05/92 (MCE) :
  540. X *                . Fixed a few potential portability problems. (Thanks
  541. X *                  to paul_smith@dg.com again.)
  542. X *                . CheckConnection () now works properly on multiheaded
  543. X *                  displays. (Thanks to brian@natinst.com for testing
  544. X *                  the `multiheaded' feature.)
  545. X *                . Better version of Sleep().
  546. X *                . Recognize X resources for class "Xautolock".
  547. X *                . Don't update timer while sighupped.
  548. X *                . Switched to vfork () and execl ().
  549. X *                . New copyright notice.
  550. X *              - 11/05/92 (MCE) :
  551. X *                . Close stdout and stderr in stead of using "2>&- 1>&-".
  552. X *                  (Suggested by sinkwitz@ifi.unizh.ch.)
  553. X *                . Added "-noclose" for debugging. 
  554. X *
  555. X * -------------------------------------------------------------------------
  556. X *
  557. X * Please send bug reports to detroch@imec.be or eyckmans@imec.be.
  558. X *
  559. X * -------------------------------------------------------------------------
  560. X *
  561. X * Copyright 1990, 1992 by S. De Troch and MCE.
  562. X *
  563. X * Permission to use, copy, modify and distribute this software and the
  564. X * supporting documentation without fee is hereby granted, provided that :
  565. X *
  566. X *  1 : Both the above copyright notice and this permission notice
  567. X *      appear in all copies of both the software and the supporting
  568. X *      documentation.
  569. X *  2 : You don't make a profit out of it.
  570. X *
  571. X * THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  572. X * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO
  573. X * EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  574. X * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
  575. X * OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  576. X * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  577. X * PERFORMANCE OF THIS SOFTWARE.
  578. X *
  579. X ***************************************************************************/
  580. X
  581. X
  582. X
  583. X/*
  584. X *  Have a guess what this does...
  585. X *  ==============================
  586. X *
  587. X *  Warning for swm & tvtwm users : xautolock should *not* be compiled
  588. X *  with vroot.h, because it needs to know the real root window.
  589. X */
  590. X#include <stdio.h>
  591. X#include <strings.h>
  592. X#include <X11/Xlib.h>
  593. X#include <X11/Xatom.h>
  594. X#include <X11/Xresource.h>
  595. X#include <sys/types.h>
  596. X#include <sys/wait.h>
  597. X#include <signal.h>
  598. X#include <memory.h>
  599. X#include <math.h>
  600. X
  601. X#ifdef AIXV3    
  602. X#include <sys/m_wait.h>
  603. X#endif /* AIXV3 */
  604. X
  605. X#if !defined (news1800) && !defined (sun386)
  606. X
  607. X#include <stdlib.h>
  608. X
  609. X#ifndef apollo
  610. X#include <malloc.h>
  611. X#include <unistd.h>
  612. X#endif /* apollo */
  613. X
  614. X#endif /* !news1800 && !sun386 */
  615. X
  616. X#include "patchlevel.h"
  617. X
  618. X
  619. X
  620. X
  621. X/*
  622. X *  Usefull macros and customization stuff
  623. X *  ======================================
  624. X */
  625. X#ifdef HasPrototypes
  626. X#define PP(x)                      x
  627. X#else /* HasPrototypes */
  628. X#define PP(x)                      ()
  629. X#endif /* HasPrototypes */
  630. X
  631. X
  632. X#define FALSE                      0       /* as it says                   */
  633. X#define TRUE                       1       /* as it says                   */
  634. X
  635. X#define ALL_OK                     0       /* for use by exit ()           */
  636. X#define PROBLEMS                   1       /* for use by exit ()           */
  637. X#define BELL_PERCENT               40      /* as is says                   */
  638. X#define MIN_MINUTES                1       /* minimum number of minutes
  639. X                          before firing up the locker  */
  640. X#define MINUTES                    10      /* default ...                  */
  641. X#define MAX_MINUTES                60      /* maximum ...                  */
  642. X#define INITIAL_SLEEP              20      /* for machines on which the
  643. X                             login sequence takes forever */
  644. X#define INCREMENTAL_SLEEP          1       /* time step in seconds         */
  645. X#define CREATION_DELAY             30      /* should be > 10 and
  646. X                           < min (45,(MIN_MINUTES*30))  */
  647. X#define CORNER_SIZE                10      /* size in pixels of the
  648. X                            force-lock areas             */
  649. X#define CORNER_DELAY               5       /* number of seconds to wait
  650. X                          before forcing a lock        */
  651. X#define LOCKER                     "xlock" /* NEVER use the -root option!  */
  652. X#define CLASS                      "Xautolock"
  653. X                            /* as it says                   */
  654. X
  655. X#if SystemV == YES
  656. X#define vfork                      fork
  657. X#endif /* SystemV == YES */
  658. X
  659. X#define Main                       main
  660. X#define Min(a,b)                   (a < b ? a : b)
  661. X#define forever                    for (;;)
  662. X#define Output0(str)               (Void) fprintf (stdout, str)
  663. X#define Output1(str,arg1)          (Void) fprintf (stdout, str, arg1)
  664. X#define Output2(str,arg1,arg2)     (Void) fprintf (stdout, str, arg1, arg2)
  665. X#define Error0(str)                (Void) fprintf (stderr, str)
  666. X#define Error1(str,arg1)           (Void) fprintf (stderr, str, arg1)
  667. X#define Error2(str,arg1,arg2)      (Void) fprintf (stderr, str, arg1, arg2)
  668. X#define UpdateTimer(new_val)       if (!sighupped) timer = new_val
  669. X
  670. Xstatic void*                       ch_ptr;  /* this is dirty */
  671. X#define Skeleton(t,s)              (ch_ptr = (Void*) malloc ((unsigned) s), \
  672. X                       ch_ptr == (Void*) NULL                \
  673. X                       ?   (Error0 ("Out of memory.\n"),       \
  674. X                        (Void) exit (PROBLEMS),              \
  675. X                        (t*) NULL                            \
  676. X                       )                                     \
  677. X                        : (t*) ch_ptr                           \
  678. X                               )                                        \
  679. X
  680. X#define New(type)                  Skeleton (type, sizeof (type))
  681. X#define NewArray(type,nof_elems)   Skeleton (type, sizeof (type) * nof_elems)
  682. X
  683. X
  684. X
  685. X
  686. X/*
  687. X *  New types
  688. X *  =========
  689. X */
  690. X#if defined (apollo) || defined (news1800)
  691. Xtypedef int                        (*XErrorHandler) PP((Display*,
  692. X                               XErrorEvent*));
  693. X#endif /* apollo || news1800 */
  694. X
  695. X#if defined (news1800) || defined (sun386)
  696. Xtypedef int                        pid_t;
  697. X#endif /* news1800  || sun386 */
  698. X
  699. X#define Void                       void     /* no typedef because of VAX */
  700. Xtypedef int                        Int;
  701. Xtypedef char                       Char;
  702. Xtypedef char*                      String;
  703. Xtypedef int                        Boolean;
  704. Xtypedef caddr_t                    Caddrt;
  705. Xtypedef unsigned long              Huge;
  706. X
  707. X#ifdef HasVoidSignalReturn
  708. X#define SigRet                     Void     /* no typedef because of VAX */
  709. X#else /* HasVoidSignalReturn */
  710. Xtypedef Int                        SigRet;
  711. X#endif /* HasVoidSignalReturn */
  712. X
  713. Xtypedef SigRet                     (*SigHandler) PP((/* OS dependent */));
  714. Xtypedef Boolean                    (*OptAction)  PP((Display*, String,
  715. X                             String));
  716. Xtypedef Void                       (*OptChecker) PP((Display*));
  717. X
  718. Xtypedef enum
  719. X    {
  720. X      IGNORE,                                 /* ignore this corner  */
  721. X      DONT_LOCK,                              /* never lock          */
  722. X      FORCE_LOCK,                             /* lock immediately    */
  723. X    } CornerAction;
  724. X
  725. Xtypedef struct QueueItem_
  726. X    {
  727. X      Window                   window;        /* as it says          */
  728. X      Time                     creationtime;  /* as it says          */
  729. X      struct QueueItem_*       next;          /* as it says          */
  730. X      struct QueueItem_*       prev;          /* as it says          */
  731. X    } aQueueItem, *QueueItem;
  732. X
  733. Xtypedef struct Queue_
  734. X    {
  735. X      struct QueueItem_*       head;          /* as it says          */
  736. X      struct QueueItem_*       tail;          /* as it says          */
  737. X    } aQueue, *Queue;
  738. X
  739. Xtypedef struct Opt_
  740. X    {
  741. X      String                   name;          /* as it says          */
  742. X      XrmOptionKind            kind;          /* as it says          */
  743. X      Caddrt                   value;         /* XrmOptionNoArg only */
  744. X      OptAction                action;        /* as it says          */
  745. X      OptChecker               checker;       /* as it says          */
  746. X    } anOpt, *Opt;
  747. X
  748. X
  749. X
  750. X
  751. X/*
  752. X *  Function declarations
  753. X *  =====================
  754. X */
  755. X#ifdef news1800
  756. Xextern Void*    malloc             PP((unsigned int));
  757. X#endif /* news1800 */
  758. X 
  759. Xstatic Void     Usage              PP((String, Int));
  760. Xstatic Void     Sleep              PP((Void));
  761. Xstatic Void     EvaluateCounter    PP((Display*));
  762. Xstatic Void     QueryPointer       PP((Display*));
  763. Xstatic Void     ProcessEvents      PP((Display*, Queue));
  764. Xstatic Queue    NewQueue           PP((Void));
  765. Xstatic Void     AddToQueue         PP((Queue, Window));
  766. Xstatic Void     ProcessQueue       PP((Queue, Display*, Time));
  767. Xstatic Void     SelectEvents       PP((Display*, Window, Boolean));
  768. Xstatic Void     CheckConnection    PP((Display*, String));
  769. Xstatic Int      FetchFalseAlarm    PP((Display*, XEvent));
  770. Xstatic Void     ProcessOpts        PP((Display*, Int, String*));
  771. Xstatic Boolean  TimeAction         PP((Display*, String, String));
  772. Xstatic Boolean  LockerAction       PP((Display*, String, String));
  773. Xstatic Boolean  CornersAction      PP((Display*, String, String));
  774. Xstatic Boolean  CornerSizeAction   PP((Display*, String, String));
  775. Xstatic Boolean  CornerDelayAction  PP((Display*, String, String));
  776. Xstatic Boolean  NotifyAction       PP((Display*, String, String));
  777. Xstatic Boolean  BellAction         PP((Display*, String, String));
  778. Xstatic Boolean  NoCloseAction      PP((Display*, String, String));
  779. Xstatic Boolean  HelpAction         PP((Display*, String, String));
  780. Xstatic Boolean  VersionAction      PP((Display*, String, String));
  781. Xstatic Boolean  GetPositive        PP((String, Int*));
  782. Xstatic Void     TimeChecker        PP((Display*));
  783. Xstatic Void     NotifyChecker      PP((Display*));
  784. Xstatic Void     CornerSizeChecker  PP((Display*));
  785. Xstatic Void     BellChecker        PP((Display*));
  786. Xstatic SigRet   DisableBySignal    PP((Void));
  787. X
  788. X
  789. X
  790. X
  791. X/*
  792. X *  Global variables
  793. X *  ================
  794. X */
  795. Xstatic Time          now = 0;               /* number of sleeps since we
  796. X                               started (not `Int')        */
  797. Xstatic Int           timer = 0;             /* as it says (not `Time')    */
  798. Xstatic String        locker = LOCKER;       /* as it says                 */
  799. Xstatic Int           time_limit = MINUTES;  /* as it says (not `Time')    */
  800. Xstatic Int           notify_margin;         /* as it says (not `Time')    */
  801. Xstatic Int           bell_percent = BELL_PERCENT;
  802. X                        /* as it says                 */
  803. Xstatic Int           corner_size = CORNER_SIZE;
  804. X                        /* as it says                 */
  805. Xstatic Int           corner_delay = CORNER_DELAY;
  806. X                        /* as it says (not `Time')    */
  807. Xstatic Boolean       sighupped = FALSE;     /* whether to ignore all
  808. X                           time-outs                  */
  809. Xstatic Boolean       notify_lock = FALSE;   /* whether to notify the user
  810. X                               before locking             */
  811. Xstatic CornerAction  corners[4] = { IGNORE, IGNORE, IGNORE, IGNORE };
  812. X                                        /* default CornerActions      */
  813. Xstatic Boolean       close_output = TRUE;   /* whether to close stdout
  814. X                                               and stderr                 */
  815. Xstatic anOpt         options[] = 
  816. X                  {
  817. X                      {"help"       , XrmoptionNoArg   ,
  818. X                    (Caddrt) ""  , HelpAction       , (OptChecker) NULL},
  819. X                      {"version"    , XrmoptionNoArg   ,
  820. X                    (Caddrt) ""  , VersionAction    , (OptChecker) NULL},
  821. X                      {"locker"     , XrmoptionSepArg  ,
  822. X                    (Caddrt) NULL, LockerAction     , (OptChecker) NULL},
  823. X                      {"corners"    , XrmoptionSepArg  ,
  824. X                    (Caddrt) NULL, CornersAction    , (OptChecker) NULL},
  825. X                      {"cornersize" , XrmoptionSepArg  ,
  826. X                    (Caddrt) NULL, CornerSizeAction , CornerSizeChecker},
  827. X                      {"cornerdelay", XrmoptionSepArg  ,
  828. X                    (Caddrt) NULL, CornerDelayAction, (OptChecker) NULL},
  829. X                      {"time"       , XrmoptionSepArg  ,
  830. X                    (Caddrt) NULL, TimeAction       , TimeChecker      },
  831. X                      {"notify"     , XrmoptionSepArg  ,
  832. X                    (Caddrt) NULL, NotifyAction     , NotifyChecker    },
  833. X                      {"bell"       , XrmoptionSepArg  ,
  834. X                    (Caddrt) NULL, BellAction       , BellChecker      },
  835. X                      {"noclose"    , XrmoptionNoArg   ,
  836. X                    (Caddrt) ""  , NoCloseAction    , (OptChecker) NULL},
  837. X                  };                     /* as it says, the order is
  838. X                           important                  */
  839. X
  840. X
  841. X
  842. X
  843. X/*
  844. X *  Command line argument related functions
  845. X *  =======================================
  846. X *
  847. X *  Support functions
  848. X *  -----------------
  849. X */
  850. Xstatic Boolean  GetPositive (arg, pos)
  851. XString  arg;  /* string to scan                  */
  852. XInt*    pos;  /* adress where to store the stuff */
  853. X
  854. X{
  855. X  Char  c;           /* dummy            */
  856. X  Int   old = *pos;  /* backup old value */
  857. X
  858. X
  859. X  if (   sscanf (arg, "%d%c", pos, &c) == 1
  860. X      && *pos >= 0
  861. X     )
  862. X  {
  863. X    return TRUE;
  864. X  }
  865. X  else
  866. X  {
  867. X    *pos = old;
  868. X    return FALSE;
  869. X  }
  870. X}
  871. X
  872. X
  873. X
  874. X/*
  875. X *  Action functions
  876. X *  ----------------
  877. X */
  878. X/*ARGSUSED*/
  879. Xstatic Boolean  HelpAction (d, name, arg)
  880. XDisplay*  d;     /* display pointer */
  881. XString    name;  /* program name    */
  882. XString    arg;   /* argument value  */
  883. X
  884. X{
  885. X  Usage (name, ALL_OK);
  886. X
  887. X  return TRUE;  /* for lint and gcc */
  888. X}
  889. X
  890. X
  891. X/*ARGSUSED*/
  892. Xstatic Boolean  VersionAction (d, name, arg)
  893. XDisplay*  d;     /* display pointer */
  894. XString    name;  /* program name    */
  895. XString    arg;   /* argument value  */
  896. X
  897. X{
  898. X  Error2 ("%s : patchlevel %d\n", name, PATCHLEVEL);
  899. X  (Void) exit (ALL_OK);
  900. X
  901. X  return TRUE;  /* for lint and gcc */
  902. X}
  903. X
  904. X
  905. X/*ARGSUSED*/
  906. Xstatic Boolean  CornerSizeAction (d, name, arg)
  907. XDisplay*  d;     /* display pointer */
  908. XString    name;  /* program name    */
  909. XString    arg;   /* argument value  */
  910. X
  911. X{
  912. X  return GetPositive (arg, &corner_size);
  913. X}
  914. X
  915. X
  916. X/*ARGSUSED*/
  917. Xstatic Boolean  CornerDelayAction (d, name, arg)
  918. XDisplay*  d;     /* display pointer */
  919. XString    name;  /* program name    */
  920. XString    arg;   /* argument value  */
  921. X
  922. X{
  923. X  return GetPositive (arg, &corner_delay);
  924. X}
  925. X
  926. X
  927. X/*ARGSUSED*/
  928. Xstatic Boolean  TimeAction (d, name, arg)
  929. XDisplay*  d;     /* display pointer */
  930. XString    name;  /* program name    */
  931. XString    arg;   /* argument value  */
  932. X
  933. X{
  934. X  return GetPositive (arg, &time_limit);
  935. X}
  936. X
  937. X
  938. X/*ARGSUSED*/
  939. Xstatic Boolean  NotifyAction (d, name, arg)
  940. XDisplay*  d;     /* display pointer */
  941. XString    name;  /* program name    */
  942. XString    arg;   /* argument value  */
  943. X
  944. X{
  945. X  return notify_lock = GetPositive (arg, ¬ify_margin);
  946. X}
  947. X
  948. X
  949. X/*ARGSUSED*/
  950. Xstatic Boolean  BellAction (d, name, arg)
  951. XDisplay*  d;     /* display pointer */
  952. XString    name;  /* program name    */
  953. XString    arg;   /* argument value  */
  954. X
  955. X{
  956. X  return GetPositive (arg, &bell_percent);
  957. X}
  958. X
  959. X
  960. X/*ARGSUSED*/
  961. Xstatic Boolean  NoCloseAction (d, name, arg)
  962. XDisplay*  d;     /* display pointer */
  963. XString    name;  /* program name    */
  964. XString    arg;   /* argument value  */
  965. X
  966. X{
  967. X  close_output = FALSE;
  968. X  return TRUE;
  969. X}
  970. X
  971. X
  972. X/*ARGSUSED*/
  973. Xstatic Boolean  LockerAction (d, name, arg)
  974. XDisplay*  d;     /* display pointer */
  975. XString    name;  /* program name    */
  976. XString    arg;   /* argument value  */
  977. X
  978. X{
  979. X  locker = arg;
  980. X  return TRUE;
  981. X}
  982. X
  983. X
  984. X/*ARGSUSED*/
  985. Xstatic Boolean  CornersAction (d, name, arg)
  986. XDisplay*  d;     /* display pointer */
  987. XString    name;  /* program name    */
  988. XString    arg;   /* argument value  */
  989. X
  990. X{
  991. X  Int  c;  /* loop counter */
  992. X
  993. X
  994. X  if (strlen (arg) == 4)
  995. X  {
  996. X    for (c = -1; ++c < 4; )
  997. X    {
  998. X      switch (arg[c])
  999. X      {
  1000. X    case '0' :
  1001. X      corners[c] = IGNORE;
  1002. X      continue;
  1003. X
  1004. X    case '-' :
  1005. X      corners[c] = DONT_LOCK;
  1006. X      continue;
  1007. X
  1008. X    case '+' :
  1009. X      corners[c] = FORCE_LOCK;
  1010. X      continue;
  1011. X
  1012. X    default :
  1013. X      return FALSE;
  1014. X      }
  1015. X    }
  1016. X
  1017. X    return TRUE;
  1018. X  }
  1019. X  else
  1020. X  {
  1021. X    return FALSE;
  1022. X  }
  1023. X}
  1024. X
  1025. X
  1026. X
  1027. X/*
  1028. X *  Consistency checkers
  1029. X *  --------------------
  1030. X */
  1031. X/*ARGSUSED*/
  1032. Xstatic Void  TimeChecker (d)
  1033. XDisplay*  d;  /* display pointer */
  1034. X
  1035. X{
  1036. X  if (time_limit < MIN_MINUTES)
  1037. X  {
  1038. X    Error1 ("Setting time to minimum value of %d minute(s).\n",
  1039. X            time_limit = MIN_MINUTES);
  1040. X  }
  1041. X  else if (time_limit > MAX_MINUTES)
  1042. X  {
  1043. X    Error1 ("Setting time to maximum value of %d minute(s).\n",
  1044. X            time_limit = MAX_MINUTES);
  1045. X  }
  1046. X
  1047. X  time_limit *= 60; /* convert to seconds */
  1048. X}
  1049. X
  1050. X
  1051. X/*ARGSUSED*/
  1052. Xstatic Void  NotifyChecker (d)
  1053. XDisplay*  d;  /* display pointer */
  1054. X
  1055. X{
  1056. X  if (   notify_lock
  1057. X      && notify_margin >= time_limit / 2
  1058. X     )
  1059. X  {
  1060. X    Error1 ("Notification time set to %d seconds.\n",
  1061. X            notify_margin = time_limit / 2);
  1062. X  }
  1063. X}
  1064. X
  1065. X
  1066. X/*ARGSUSED*/
  1067. Xstatic Void  BellChecker (d)
  1068. XDisplay*  d;  /* display pointer */
  1069. X
  1070. X{
  1071. X  if (   bell_percent < 1
  1072. X      || bell_percent > 100
  1073. X     )
  1074. X  {
  1075. X    Error1 ("Bell percentage set to %d%%.\n",
  1076. X        bell_percent = BELL_PERCENT);
  1077. X  }
  1078. X}
  1079. X
  1080. X
  1081. X/*ARGSUSED*/
  1082. Xstatic Void  CornerSizeChecker (d)
  1083. XDisplay*  d;  /* display pointer */
  1084. X
  1085. X{
  1086. X  Int      s;                /* screen index   */
  1087. X  Screen*  scr;              /* screen pointer */
  1088. X  Int      max_corner_size;  /* as it says     */
  1089. X  
  1090. X
  1091. X  for (max_corner_size = 32000, s = -1; ++s < ScreenCount (d); )
  1092. X  {
  1093. X    scr = ScreenOfDisplay (d, s);
  1094. X
  1095. X    if (   max_corner_size > WidthOfScreen (scr) / 4
  1096. X    || max_corner_size > HeightOfScreen (scr) / 4
  1097. X       )
  1098. X    {
  1099. X      max_corner_size = Min (WidthOfScreen (scr), HeightOfScreen (scr)) / 4;
  1100. X    }
  1101. X  }
  1102. X
  1103. X  if (corner_size > max_corner_size)
  1104. X  {
  1105. X    Error1 ("Corner size set to %d pixels.\n",
  1106. X        corner_size = max_corner_size);
  1107. X  }
  1108. X}
  1109. X
  1110. X
  1111. X
  1112. X/*
  1113. X *  Function for informing the user about syntax errors
  1114. X *  ---------------------------------------------------
  1115. X */
  1116. Xstatic Void  Usage (prog_name, exit_code)
  1117. XString  prog_name;  /* as it says */
  1118. XInt     exit_code;  /* as it says */
  1119. X
  1120. X{
  1121. X  String  blanks;  /* string full of blanks */
  1122. X  size_t  len;     /* number of blanks      */
  1123. X
  1124. X
  1125. X /*
  1126. X  *  The relative overhead is enormous here, but who cares.
  1127. X  *  I'm a perfectionist and Usage () doesn't return anyway.
  1128. X  */
  1129. X  len = strlen ("Usage : ") + strlen (prog_name) + 1;
  1130. X  (Void) memset (blanks = NewArray (Char, len + 1), ' ', len);
  1131. X  blanks[len] = '\0';
  1132. X
  1133. X
  1134. X /*
  1135. X  *  This is where the actual work gets done...
  1136. X  */
  1137. X  Error0 ("\n");
  1138. X  Error1 ("Usage : %s ", prog_name);
  1139. X  Error0 ("[-help][-version][-time minutes][-locker locker]\n");
  1140. X  Error0 (blanks);
  1141. X  Error0 ("[-notify margin][-bell percent][-corners xxxx]\n");
  1142. X  Error0 (blanks);
  1143. X  Error0 ("[-cornerdelay secs][-cornersize pixels][-noclose]\n");
  1144. X
  1145. X  Error0 ("\n");
  1146. X  Error0 (" -help              : print this message and exit.\n");
  1147. X  Error0 (" -version           : print version number and exit.\n");
  1148. X  Error2 (" -time minutes      : time to lock screen [%d < minutes < %d].\n",
  1149. X                             MIN_MINUTES, MAX_MINUTES);
  1150. X  Error0 (" -locker locker     : program used to lock.\n");
  1151. X  Error0 (" -notify margin     : beep this many seconds before locking.\n");
  1152. X  Error0 (" -bell percent      : loudness of the beep.\n");
  1153. X  Error0 (" -corners xxxx      : corner actions (0, +, -) in this order :\n");
  1154. X  Error0 ("                      topleft topright bottomleft bottomright\n");
  1155. X  Error0 (" -cornerdelay secs  : time to lock screen in a `+' corner.\n");
  1156. X  Error0 (" -cornersize pixels : size of corner areas.\n");
  1157. X  Error0 (" -noclose           : do not close stdout and stderr.\n");
  1158. X
  1159. X  Error0 ("\n");
  1160. X  Error0 ("Defaults :\n");
  1161. X
  1162. X  Error0 ("\n");
  1163. X  Error1 ("  time        : %d minutes\n"  , MINUTES     );
  1164. X  Error1 ("  locker      : %s\n"          , LOCKER      );
  1165. X  Error0 ("  notify      : don't beep\n"                );
  1166. X  Error0 ("  bell        : 40%%\n"                      );
  1167. X  Error0 ("  corners     : 0000\n"                      );
  1168. X  Error1 ("  cornerdelay : %d seconds\n"  , CORNER_DELAY);
  1169. X  Error1 ("  cornersize  : %d pixels\n"   , CORNER_SIZE );
  1170. X
  1171. X  Error0 ("\n");
  1172. X
  1173. X  exit (exit_code);
  1174. X}
  1175. X
  1176. X
  1177. X
  1178. X/*
  1179. X *  Function for processing command line arguments
  1180. X *  ----------------------------------------------
  1181. X */
  1182. Xstatic Void  ProcessOpts (d, argc, argv)
  1183. XDisplay*  d;       /* display pointer     */
  1184. XInt       argc;    /* number of arguments */
  1185. XString    argv[];  /* array of arguments  */
  1186. X
  1187. X{
  1188. X  Int                nof_options = sizeof (options) / sizeof (anOpt);
  1189. X                              /* number of supported options   */
  1190. X  Int                j;           /* loop counter                  */
  1191. X  Int                l;           /* temporary storage             */
  1192. X  Char*              ptr;         /* temporary storage             */
  1193. X  Char               buffer[80];  /* as it says                    */
  1194. X  Char*              dummy;       /* as it says                    */
  1195. X  XrmValue           value;       /* resource value container      */
  1196. X  XrmOptionDescList  xoptions;    /* optionslist in Xlib format    */
  1197. X  XrmDatabase        db = (XrmDatabase) NULL;
  1198. X                  /* command line options database */
  1199. X
  1200. X
  1201. X /*
  1202. X  *  Beautify argv[0].
  1203. X  */
  1204. X  for (ptr = argv[0] + strlen (argv[0]) - 1; ptr >= argv[0]; ptr--)
  1205. X  {
  1206. X    if (*ptr == '/')
  1207. X    {
  1208. X      break;
  1209. X    }
  1210. X  }
  1211. X
  1212. X  argv[0] = ptr + 1;
  1213. X
  1214. X
  1215. X /*
  1216. X  *  Calling XGetDefault () on a dummy resource is the easiest 
  1217. X  *  way to get both Xrm and d->db initialized.
  1218. X  */
  1219. X  (Void) XGetDefault (d, argv[0], "dummy");
  1220. X
  1221. X
  1222. X /*
  1223. X  *  Parse the command line options into a resource database. (The
  1224. X  *  command line database and the resource file database are not
  1225. X  *  merged, because we want to know where exactly each resource
  1226. X  *  value came from.)
  1227. X  */
  1228. X  xoptions = NewArray (XrmOptionDescRec, nof_options);
  1229. X
  1230. X  for (j = -1; ++j < nof_options; )
  1231. X  {
  1232. X    l = strlen (options[j].name);
  1233. X
  1234. X    (Void) sprintf (xoptions[j].option = NewArray (Char, l + 2),
  1235. X                "-%s", options[j].name);
  1236. X    (Void) sprintf (xoptions[j].specifier = NewArray (Char, l + 2),
  1237. X                ".%s", options[j].name);
  1238. X    xoptions[j].argKind = options[j].kind;
  1239. X    xoptions[j].value = options[j].value;
  1240. X  }
  1241. X
  1242. X  XrmParseCommand (&db, xoptions, nof_options, argv[0], &argc, argv);
  1243. X
  1244. X  if (--argc)
  1245. X  {
  1246. X    Usage (argv[0], PROBLEMS);
  1247. X  }
  1248. X
  1249. X  for (j = -1; ++j < nof_options; )
  1250. X  {
  1251. X    free (xoptions[j].option);
  1252. X    free (xoptions[j].specifier);
  1253. X  }
  1254. X
  1255. X  free (xoptions);
  1256. X
  1257. X
  1258. X /*
  1259. X  *  Call the action functions.
  1260. X  */
  1261. X  for (j = -1; ++j < nof_options; )
  1262. X  {
  1263. X    (Void) sprintf (buffer, "%s%s", argv[0], xoptions[j].specifier);
  1264. X
  1265. X    if (XrmGetResource (db, buffer, (String) NULL, &dummy, &value))
  1266. X    {
  1267. X      if (!(*(options[j].action)) (d, argv[0], value.addr))
  1268. X      {
  1269. X        Usage (argv[0], PROBLEMS); 
  1270. X      }
  1271. X    }
  1272. X    else if (XrmGetResource (d->db, buffer, (String) NULL, &dummy, &value))
  1273. X    {
  1274. X      if (!(*(options[j].action)) (d, argv[0], value.addr))
  1275. X      {
  1276. X        Error2 ("Can't interprete \"%s\" for \"%s\", using default.\n", 
  1277. X            value.addr, buffer);
  1278. X      }
  1279. X    }
  1280. X    else
  1281. X    {
  1282. X      (Void) sprintf (buffer, "%s%s", CLASS, xoptions[j].specifier);
  1283. X
  1284. X      if (   XrmGetResource (d->db, buffer, (String) NULL, &dummy, &value)
  1285. X          && !(*(options[j].action)) (d, argv[0], value.addr)
  1286. X         )
  1287. X      {
  1288. X        Error2 ("Can't interprete \"%s\" for \"%s\", using default.\n", 
  1289. X            value.addr, buffer);
  1290. X      }
  1291. X    }
  1292. X  }
  1293. X
  1294. X
  1295. X
  1296. X /*
  1297. X  *  Call the consistency checkers.
  1298. X  */
  1299. X  for (j = -1; ++j < nof_options; )
  1300. X  {
  1301. X    if (options[j].checker != (OptChecker) NULL)
  1302. X    {
  1303. X      (*(options[j].checker)) (d);
  1304. X    }
  1305. X  }
  1306. X}
  1307. X
  1308. X
  1309. X
  1310. X
  1311. X/*
  1312. X *  Functions related to the window queue
  1313. X *  =====================================
  1314. X *
  1315. X *  Function for creating a new queue
  1316. X *  ---------------------------------
  1317. X */
  1318. Xstatic Queue  NewQueue ()
  1319. X
  1320. X{
  1321. X  Queue  queue;  /* return value */
  1322. X
  1323. X
  1324. X  queue = New (aQueue);
  1325. X  queue->tail = New (aQueueItem);
  1326. X  queue->head = New (aQueueItem);
  1327. X
  1328. X  queue->tail->next = queue->head;
  1329. X  queue->head->prev = queue->tail;
  1330. X  queue->tail->prev = queue->head->next = (QueueItem) NULL;
  1331. X
  1332. X  return queue;
  1333. X}
  1334. X
  1335. X
  1336. X
  1337. X/*
  1338. X *  Function for adding an item to a queue
  1339. X *  --------------------------------------
  1340. X */
  1341. Xstatic Void  AddToQueue (queue, window)
  1342. XQueue   queue;   /* as it says */
  1343. XWindow  window;  /* as it says */
  1344. X
  1345. X{
  1346. X  QueueItem  new;  /* new item */
  1347. X
  1348. X
  1349. X  new = New (aQueueItem);
  1350. X
  1351. X  new->window = window;
  1352. X  new->creationtime = now;
  1353. X  new->next = queue->tail->next;
  1354. X  new->prev = queue->tail;
  1355. X  queue->tail->next->prev = new;
  1356. X  queue->tail->next = new;
  1357. X}
  1358. X
  1359. X
  1360. X
  1361. X/*
  1362. X *  Function for processing those entries that are old enough
  1363. X *  ---------------------------------------------------------
  1364. X */
  1365. Xstatic Void  ProcessQueue (queue, d, age)
  1366. XQueue     queue;  /* as it says      */
  1367. XDisplay*  d;      /* display pointer */
  1368. XTime      age;    /* required age    */
  1369. X
  1370. X{
  1371. X  QueueItem  current;  /* as it says */
  1372. X
  1373. X
  1374. X  if (now > age)
  1375. X  {
  1376. X    current = queue->head->prev;
  1377. X
  1378. X    while (   current->prev
  1379. X       && current->creationtime + age < now
  1380. X      )
  1381. X    {
  1382. X      SelectEvents (d, current->window, False);
  1383. X      current = current->prev;
  1384. X      free (current->next);
  1385. X    }
  1386. X
  1387. X    current->next = queue->head;
  1388. X    queue->head->prev = current;
  1389. X  }
  1390. X}
  1391. X
  1392. X
  1393. X
  1394. X
  1395. X/*
  1396. X *  Functions related to (the lack of) user activity
  1397. X *  ================================================
  1398. X *
  1399. X *  Function for processing the event queue
  1400. X *  ---------------------------------------
  1401. X */
  1402. Xstatic Void  ProcessEvents (d, queue)
  1403. XDisplay*  d;      /* display pointer */
  1404. XQueue     queue;  /* as it says      */
  1405. X
  1406. X{
  1407. X  XEvent  event;  /* as it says */
  1408. X
  1409. X
  1410. X /*
  1411. X  *  Read whatever is available for reading.
  1412. X  */
  1413. X  while (XPending (d))
  1414. X  {
  1415. X    if (XCheckMaskEvent (d, SubstructureNotifyMask, &event))
  1416. X    {
  1417. X      if (event.type == CreateNotify)
  1418. X      {
  1419. X    AddToQueue (queue, event.xcreatewindow.window);
  1420. X      }
  1421. X    }
  1422. X    else
  1423. X    {
  1424. X      XNextEvent (d, &event);
  1425. X    }
  1426. X
  1427. X
  1428. X   /*
  1429. X    *  Reset the counter if and only if the event is of one of
  1430. X    *  the types we are expecting to get *and* was not generated by
  1431. X    *  XSendEvent ().
  1432. X    */
  1433. X    if (   event.type == KeyPress
  1434. X    && !event.xany.send_event
  1435. X       )
  1436. X    {
  1437. X      UpdateTimer (0);
  1438. X    }
  1439. X  }
  1440. X
  1441. X
  1442. X /*
  1443. X  *  Check the window queue for entries that are older than
  1444. X  *  CREATION_DELAY seconds.
  1445. X  */
  1446. X  ProcessQueue (queue, d, (Time) CREATION_DELAY);
  1447. X}
  1448. X
  1449. X
  1450. X
  1451. X/*
  1452. X *  Function for monitoring pointer movements
  1453. X *  -----------------------------------------
  1454. X */
  1455. Xstatic Void  QueryPointer (d)
  1456. XDisplay*  d;  /* display pointer */
  1457. X
  1458. X{
  1459. X  Window          dummy_w;            /* as it says                    */
  1460. X  Int             dummy_c;            /* as it says                    */
  1461. X  Mask            dummy_m;            /* as it says                    */
  1462. X  Int             root_x;             /* as it says                    */
  1463. X  Int             root_y;             /* as it says                    */
  1464. X  Int             corner;             /* corner index                  */
  1465. X  Int             i;                  /* loop counter                  */
  1466. X  static Window   root;               /* root window the pointer is on */
  1467. X  static Screen*  screen;             /* screen the pointer is on      */
  1468. X  static Int      prev_root_x = -1;   /* as it says                    */
  1469. X  static Int      prev_root_y = -1;   /* as it says                    */
  1470. X  static Boolean  first_call = TRUE;  /* as it says                    */
  1471. X
  1472. X
  1473. X /*
  1474. X  *  Have a guess...
  1475. X  */
  1476. X  if (first_call)
  1477. X  {
  1478. X    first_call = FALSE;
  1479. X    root = DefaultRootWindow (d);
  1480. X    screen = ScreenOfDisplay (d, DefaultScreen (d));
  1481. X  }
  1482. X
  1483. X
  1484. X /*
  1485. X  *  Find out whether the pointer has moved. Using XQueryPointer for this
  1486. X  *  is gross, but it also is the only way never to mess up propagation
  1487. X  *  of pointer events.
  1488. X  *
  1489. X  *  Remark : Unlike XNextEvent(), XPending () doesn't notice if the
  1490. X  *           connection to the server is lost. For this reason, earlier
  1491. X  *           versions of xautolock periodically called XNoOp (). But
  1492. X  *           why not let XQueryPointer () do the job for us, since
  1493. X  *           we now call it every INCREMENTAL_SLEEP seconds anyway?
  1494. X  */
  1495. X  if (!XQueryPointer (d, root, &root, &dummy_w, &root_x, &root_y,
  1496. X              &dummy_c, &dummy_c, &dummy_m))
  1497. X  {
  1498. X   /*
  1499. X    *  Pointer has moved to another screen, so let's find out which one.
  1500. X    */
  1501. X    for (i = -1; ++i < ScreenCount (d); ) 
  1502. X    {
  1503. X      if (root == RootWindow (d, i)) 
  1504. X      {
  1505. X        screen = ScreenOfDisplay (d, i);
  1506. X    break;
  1507. X      }
  1508. X    }
  1509. X  }
  1510. X
  1511. X  if (   root_x == prev_root_x
  1512. X      && root_y == prev_root_y
  1513. X     )
  1514. X  {
  1515. X   /*
  1516. X    *  If the pointer has not moved since the previous call and 
  1517. X    *  is inside one of the 4 corners, we act according to the
  1518. X    *  contents of the "corners" array.
  1519. X    */
  1520. X    if (   (corner = 0,
  1521. X           root_x <= corner_size
  1522. X        && root_y <= corner_size
  1523. X       )
  1524. X    || (corner++,
  1525. X           root_x >= WidthOfScreen  (screen) - corner_size - 1
  1526. X        && root_y <= corner_size
  1527. X       )
  1528. X    || (corner++,
  1529. X           root_x <= corner_size
  1530. X        && root_y >= HeightOfScreen (screen) - corner_size - 1
  1531. X       )
  1532. X    || (corner++,
  1533. X           root_x >= WidthOfScreen  (screen) - corner_size - 1
  1534. X        && root_y >= HeightOfScreen (screen) - corner_size - 1
  1535. X       )
  1536. X       )
  1537. X    {
  1538. X      switch (corners[corner])
  1539. X      {
  1540. X    case FORCE_LOCK :
  1541. X      if (timer < time_limit - corner_delay + 2)
  1542. X      {
  1543. X        UpdateTimer (time_limit - corner_delay + 2);
  1544. X      }
  1545. X      break;
  1546. X
  1547. X    case DONT_LOCK :
  1548. X      UpdateTimer (0);
  1549. X      }
  1550. X    }
  1551. X  }
  1552. X  else
  1553. X  {
  1554. X    prev_root_x = root_x;
  1555. X    prev_root_y = root_y;
  1556. X    UpdateTimer (0);
  1557. X  }
  1558. X}
  1559. X
  1560. X
  1561. X
  1562. X/*
  1563. X *  Function for deciding whether to lock
  1564. X *  -------------------------------------
  1565. X */
  1566. Xstatic Void  EvaluateCounter (d)
  1567. XDisplay*  d;  /* display pointer */
  1568. X
  1569. X{
  1570. X  static pid_t  locker_pid = 0;  /* child pid  */
  1571. X  static Time   prev_bell = 0;   /* as it says */
  1572. X
  1573. X
  1574. X /*
  1575. X  *  Find out whether we should do something special. This can
  1576. X  *  be one (or more) of the following :
  1577. X  *
  1578. X  *   - Wait for the previous locker (if any).
  1579. X  *   - Ring the bell, if we were asked to and are about to lock.
  1580. X  *   - Start up a new locker if the time limit has been reached.
  1581. X  */
  1582. X  if (locker_pid)
  1583. X  {
  1584. X    union wait  status;  /* childs process status */
  1585. X
  1586. X
  1587. X    if (!wait3 (&status, WNOHANG, (struct rusage*) NULL))
  1588. X    {
  1589. X      UpdateTimer (0);
  1590. X    }
  1591. X    else
  1592. X    {
  1593. X      locker_pid = 0;
  1594. X    }
  1595. X  }
  1596. X
  1597. X  if (   notify_lock
  1598. X      && timer + notify_margin > time_limit
  1599. X      && prev_bell < now - notify_margin - 1
  1600. X     )
  1601. X  {
  1602. X    prev_bell = now;
  1603. X    XBell (d, bell_percent);
  1604. X    XSync (d, 0);
  1605. X  }
  1606. X
  1607. X  if (timer > time_limit)
  1608. X  {
  1609. X    if (!locker_pid)
  1610. X    {
  1611. X      switch (locker_pid = vfork ())
  1612. X      {
  1613. X    case -1 :
  1614. X      locker_pid = 0;
  1615. X      break;
  1616. X
  1617. X    case 0 :
  1618. X      (Void) close (ConnectionNumber (d));
  1619. X      (Void) execl ("/bin/sh", "sh", "-c", locker, (String) NULL);
  1620. X      (Void) _exit (PROBLEMS);
  1621. X
  1622. X    default :
  1623. X      UpdateTimer (0);
  1624. X      }
  1625. X    }
  1626. X  }
  1627. X}
  1628. X
  1629. X
  1630. X
  1631. X
  1632. X/*
  1633. X *  Miscellaneous functions
  1634. X *  =======================
  1635. X *
  1636. X *  X Error handler
  1637. X *  ---------------
  1638. X */
  1639. X/*ARGSUSED*/
  1640. Xstatic Int  FetchFalseAlarm (d, event)
  1641. XDisplay*  d;      /* display pointer */
  1642. XXEvent    event;  /* error event     */
  1643. X
  1644. X{
  1645. X  return 0;
  1646. X}
  1647. X
  1648. X
  1649. X
  1650. X/*
  1651. X *  SIGHUP signal handler
  1652. X *  ---------------------
  1653. X */
  1654. Xstatic SigRet  DisableBySignal ()
  1655. X
  1656. X{
  1657. X /*
  1658. X  *  The order in which things are done is rather important here.
  1659. X  */
  1660. X  UpdateTimer (0);
  1661. X  sighupped = !sighupped;
  1662. X  (Void) signal (SIGHUP, (SigHandler) DisableBySignal);
  1663. X
  1664. X#ifndef HasVoidSignalReturn 
  1665. X  return 0;
  1666. X#endif /* HasVoidSignalReturn */
  1667. X}
  1668. X
  1669. X
  1670. X
  1671. X/*
  1672. X *  Lazy function
  1673. X *  -------------
  1674. X */
  1675. Xstatic Void  Sleep ()
  1676. X
  1677. X{
  1678. X  Int  i;  /* loop counter */
  1679. X
  1680. X
  1681. X  for (i = -1; ++i < INCREMENTAL_SLEEP; )
  1682. X  {
  1683. X    (Void) sleep (1);
  1684. X    UpdateTimer (timer + 1);
  1685. X    now++;
  1686. X  }
  1687. X}
  1688. X
  1689. X
  1690. X
  1691. X/*
  1692. X *  Function for finding out whether another xautolock is already running
  1693. X *  ---------------------------------------------------------------------
  1694. X */
  1695. Xstatic Void  CheckConnection (d, prog_name)
  1696. XDisplay*  d;          /* display pointer */
  1697. XString    prog_name;  /* as it says      */
  1698. X
  1699. X{
  1700. X  pid_t   pid;        /* as it says              */
  1701. X  Int     kill_val;   /* return value of kill () */
  1702. X  Window  r;          /* root window             */
  1703. X  Atom    property;   /* property atom           */
  1704. X  Atom    type;       /* property type atom      */
  1705. X  Int     format;     /* property format         */
  1706. X  Huge    nof_items;  /* actual number of items  */
  1707. X  Huge    after;      /* dummy                   */
  1708. X  pid_t*  contents;   /* actual property value   */
  1709. X
  1710. X
  1711. X  r = RootWindowOfScreen (ScreenOfDisplay (d, 0));
  1712. X  property = XInternAtom (d, "XAUTOLOCK_SEMAPHORE_PID", False);
  1713. X
  1714. X  XGrabServer (d);
  1715. X  XGetWindowProperty (d, r, property, 0L, 2L, False, AnyPropertyType,
  1716. X              &type, &format, &nof_items, &after,
  1717. X              (unsigned char**) &contents);
  1718. X
  1719. X  if (type == XA_INTEGER)
  1720. X  {
  1721. X   /*
  1722. X    *  This breaks if the other xautolock is not 
  1723. X    *  running on the same machine.
  1724. X    */
  1725. X    kill_val = kill (*contents, 0);
  1726. X
  1727. X    if (kill_val == 0)
  1728. X    {
  1729. X      Error2 ("%s is already running (PID %d).\n",
  1730. X          prog_name, *contents);
  1731. X      (Void) exit (PROBLEMS);
  1732. X    }
  1733. X  }
  1734. X
  1735. X  pid = getpid ();
  1736. X  XChangeProperty (d, r, property, XA_INTEGER, 8,
  1737. X               PropModeReplace, (Char*) &pid, sizeof (pid));
  1738. X  XUngrabServer (d);
  1739. X
  1740. X  XFree ((Char*) contents);
  1741. X}
  1742. X
  1743. X
  1744. X
  1745. X/*
  1746. X *  Function for selecting events on a tree of windows
  1747. X *  --------------------------------------------------
  1748. X */
  1749. Xstatic Void  SelectEvents (d, window, substructure_only)
  1750. XDisplay*  d;                  /* display pointer   */
  1751. XWindow    window;             /* window            */
  1752. XBoolean   substructure_only;  /* as it says        */
  1753. X
  1754. X{
  1755. X  Window             root;              /* root window of this window */
  1756. X  Window             parent;            /* parent of this window      */
  1757. X  Window*            children;          /* children of this window    */
  1758. X  Int                nof_children = 0;  /* number of children         */
  1759. X  Int                i;                 /* loop counter               */
  1760. X  XWindowAttributes  attribs;           /* attributes of the window   */
  1761. X
  1762. X
  1763. X /*
  1764. X  *  Start by querying the server about parent and child windows.
  1765. X  */
  1766. X  if (!XQueryTree (d, window, &root, &parent, &children, &nof_children))
  1767. X  {
  1768. X    return;
  1769. X  }
  1770. X
  1771. X
  1772. X /*
  1773. X  *  Build the appropriate event mask. The basic idea is that we don't
  1774. X  *  want to interfere with the normal event propagation mechanism if
  1775. X  *  we don't have to.
  1776. X  */
  1777. X  if (substructure_only)
  1778. X  {
  1779. X    XSelectInput (d, window, SubstructureNotifyMask);
  1780. X  }
  1781. X  else
  1782. X  {
  1783. X    if (parent == None)  /* the *real* rootwindow */
  1784. X    {
  1785. X      attribs.all_event_masks = 
  1786. X      attribs.do_not_propagate_mask = KeyPressMask;
  1787. X    }
  1788. X    else if (XGetWindowAttributes (d, window, &attribs) == 0)
  1789. X    {
  1790. X      return;
  1791. X    }
  1792. X
  1793. X    XSelectInput (d, window,   SubstructureNotifyMask
  1794. X                     | (  (  attribs.all_event_masks
  1795. X                   | attribs.do_not_propagate_mask)
  1796. X                & KeyPressMask));
  1797. X  }
  1798. X
  1799. X
  1800. X /*
  1801. X  *  Now do the same thing for all children.
  1802. X  */
  1803. X  for (i = -1; ++i < nof_children; )
  1804. X  {
  1805. X    SelectEvents (d, children[i], substructure_only);
  1806. X  }
  1807. X
  1808. X  if (nof_children != 0)
  1809. X  {
  1810. X    XFree ((Char*) children);
  1811. X  }
  1812. X}
  1813. X
  1814. X
  1815. X
  1816. X/*
  1817. X *  Main function
  1818. X *  -------------
  1819. X */
  1820. XInt  Main (argc, argv)
  1821. XInt     argc;    /* number of arguments */
  1822. XString  argv[];  /* array of arguments  */
  1823. X
  1824. X{
  1825. X  Display*  d;      /* display pointer */
  1826. X  Window    r;      /* root window     */
  1827. X  Int       s;      /* screen index    */
  1828. X  Queue     queue;  /* as it says      */
  1829. X
  1830. X
  1831. X /*
  1832. X  *  Find out whether there actually is a server on the other side...
  1833. X  */
  1834. X  if (   (d = XOpenDisplay ((String) NULL))
  1835. X      == (Display*) NULL
  1836. X     )
  1837. X  {
  1838. X    (Void) exit (PROBLEMS);
  1839. X  }
  1840. X
  1841. X
  1842. X /*
  1843. X  *  Some initializations.
  1844. X  */
  1845. X  ProcessOpts (d, argc, argv);
  1846. X
  1847. X  XSetErrorHandler ((XErrorHandler) FetchFalseAlarm);
  1848. X  CheckConnection (d, argv[0]);
  1849. X  (Void) signal (SIGHUP, (SigHandler) DisableBySignal);
  1850. X
  1851. X  XSync (d, 0);
  1852. X  (Void) sleep (INITIAL_SLEEP);
  1853. X
  1854. X  queue = NewQueue ();
  1855. X
  1856. X  for (s = -1; ++s < ScreenCount (d); )
  1857. X  {
  1858. X    AddToQueue (queue, r = RootWindowOfScreen (ScreenOfDisplay (d, s)));
  1859. X    SelectEvents (d, r, True);
  1860. X  }
  1861. X
  1862. X  if (close_output)
  1863. X  {
  1864. X    (Void) fclose (stdout);
  1865. X    (Void) fclose (stderr);
  1866. X  }
  1867. X
  1868. X
  1869. X /*
  1870. X  *  Main event loop.
  1871. X  */
  1872. X  forever
  1873. X  {
  1874. X    Sleep ();
  1875. X    ProcessEvents (d, queue);
  1876. X    QueryPointer (d);
  1877. X    EvaluateCounter (d);
  1878. X  }
  1879. X}
  1880. SHAR_EOF
  1881. if test 37774 -ne "`wc -c < 'xautolock.c'`"
  1882. then
  1883.     echo shar: error transmitting "'xautolock.c'" '(should have been 37774 characters)'
  1884. fi
  1885. fi # end of overwriting check
  1886. echo shar: extracting "'Makefile.std'" '(477 characters)'
  1887. if test -f 'Makefile.std'
  1888. then
  1889.     echo shar: will not over-write existing file "'Makefile.std'"
  1890. else
  1891. sed 's/^X//' << \SHAR_EOF > 'Makefile.std'
  1892. X#
  1893. X#  Edit these to suit your needs.
  1894. X#
  1895. X#  SystemV is only used to select between fork and vfork. It doesn't hurt
  1896. X#  to have it defined to YES, but if your system has vfork, it's more
  1897. X#  efficient to comment this stuff out.
  1898. X#
  1899. XDEFINES = -DSystemV=YES
  1900. X
  1901. XRM      = /bin/rm -f
  1902. XCC      = cc
  1903. XHDRS    = patchlevel.h
  1904. XSRCS    = xautolock.c
  1905. XOBJS    = xautolock.o
  1906. X
  1907. XLIBS    = -lX11
  1908. X
  1909. Xxautolock: $(SRCS) 
  1910. X    $(RM) $@
  1911. X    $(CC) $(DEFINES) $(SRCS) -o $@ $(LIBS) 
  1912. X
  1913. Xclean:
  1914. X    $(RM) xautolock $(OBJS) core
  1915. SHAR_EOF
  1916. if test 477 -ne "`wc -c < 'Makefile.std'`"
  1917. then
  1918.     echo shar: error transmitting "'Makefile.std'" '(should have been 477 characters)'
  1919. fi
  1920. fi # end of overwriting check
  1921. echo shar: done with directory "'xautolock'"
  1922. cd ..
  1923. #    End of shell archive
  1924. exit 0
  1925.